package com.zl.protocol.des;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;

/**
 * <p>
 * Title: 字节处理工具类
 * </p>
 *
 * <p>
 * Description: net.qysoft.framwork.util-byteUtil.java
 * </p>
 *
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 *
 * <p>
 * Company: 中卡公司
 * </p>
 *
 * @author Zheng_wh 2008-10-15
 * @version 1.0
 * @PC_UserName Administrator
 */
public class byteUtils {

    /**
     * 得到指定字节串中，从start位开始到len结束的字节串
     *
     * @param b     需要处理的字节串
     * @param start 开始位，首位为0;
     * @param len   从首位向后的位数个数
     * @return
     */
    public static byte[] getInbyte(byte[] b, int start, int len) {
        byte[] temp = new byte[len];

        if (b.length < len)
            return b;
        else if (start < 0)
            return b;
        else if (b.length < start)
            return b;
        else if (b.length < start + len)
            return b;
        int j = 0;
        for (int i = start; i < start + len; i++, j++)
            temp[j] = b[i];

        return temp;

    }

    /**
     * 将全部字节流全部取反
     *
     * @param b
     * @return
     */
    public static byte[] getNegationBytes(byte[] b) {
        byte[] temp = new byte[b.length];

        for (int i = 0; i < b.length; i++)
            temp[i] = (byte) ~b[i];

        return temp;
    }

    /**
     * 得到一个字位串的颠倒字位串
     *
     * @param b
     * @return
     */
    public static byte[] getReversalByte(byte[] b) {
        if (b.length < 1)
            return b;

        byte[] temp = new byte[b.length];

        for (int i = b.length - 1; i >= 0; i--)
            temp[b.length - i - 1] = b[i];

        return temp;
    }

    public static byte[] getConBytes(byte[] b) {
        byte[] temp = new byte[b.length];
        for (int i = 0; i < b.length; i++)
            temp[i] = (byte) ~b[i];

        return temp;
    }

    /**
     * 将汉字转换成为ASCII
     *
     * @param s 汉字
     * @return
     */
    public static String getASCII(String s) {
        if (s == null || s.length() == 0)
            return null;
        try {

            return byteUtils.Bytes2HexString(s.getBytes("GB2312"));

        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            return null;
        }
    }

    /**
     * 将汉字转换成为字节
     *
     * @param s      汉字
     * @param length 需要转换的个数
     * @return
     */
    public static byte[] getBytesByGB2312String(String s, int length) {
        if (s == null || s.length() == 0)
            return null;
        try {
            byte[] valuesBytes = new byte[length * 2];
            for (int i = 0; i < length * 2; i++) {
                valuesBytes[i] = 0x20;
            }
            byte[] temps = s.getBytes("GB2312");
            for (int i = 0; i < temps.length; i++) {
                valuesBytes[i] = temps[i];
            }
            return valuesBytes;
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            return null;
        }
    }

    /**
     * 将汉字转换成为字节
     *
     * @param s         汉字
     * @param maxlength 汉字总个数
     * @return
     */
    public static byte[] getBytesByGB2312String2(String s, int maxlength) {
        if (s == null || s.length() == 0)
            return null;
        try {
            byte[] valuesBytes = new byte[maxlength * 2];
            for (int i = 0; i < maxlength * 2; i++) {
                valuesBytes[i] = 0x20;
            }
            byte[] temps = s.getBytes("GB2312");
            for (int i = 0; i < maxlength * 2; i++) {
                if (i > (temps.length - 1))
                    break;
                valuesBytes[i] = temps[i];
            }
            return valuesBytes;
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            return null;
        }
    }

    /**
     * 将字节码转换为姓名
     *
     * @param bytes 字节数组
     * @return
     */
    public static String getGb2312StringByByteS(byte[] bytes) {
        String temp = "";
        if (bytes.length == 0)
            return temp;

        temp = Bytes2HexString(bytes).replaceAll("20", "");
        return new String(byteUtils.HexString2Bytes(temp));

    }

    /**
     * 替换指定字节串中的值
     *
     * @param bytes 要处理的字节串
     * @param start 开始替换的位置
     * @param temps 需要替换的字节串
     * @return
     */
    public static byte[] getReplaceBytesByParameter(byte[] bytes, int start,
                                                    byte[] temps) {
        // 替换的长度要小于要替换的长度
        if (temps.length > bytes.length)
            return bytes;
        // 开始的长度位，小于要替换的长度
        if (start > bytes.length)
            return bytes;
        // 开始的长度位＋替换的长度小于替换的长度
        if (start + temps.length > bytes.length)
            return bytes;
        int i = 0;
        while (temps.length > i) {
            bytes[start + i] = temps[i];
            i++;
        }
        return bytes;
    }

    /**
     * 字节数组累加和
     *
     * @param bytes 需要处理的字节数组
     * @param isNot 是否取非
     * @return
     */
    public static byte getByteByBytesSum(byte[] bytes, boolean isNot) {

        byte sumtemp = bytes[0];
        // 如果字节串长度大于是，则改变初始化temp的值。
        if (bytes.length > 1)
            sumtemp = bytes[0];
            // 字节串只为1值
        else {
            if (isNot)
                sumtemp = (byte) ~sumtemp;
            return sumtemp;
        }

        int i = 1;
        // 字节串大于是时，才处理异或操作
        while (bytes.length > i) {
            // 执行或 &与 ｜或 ~非
            sumtemp = (byte) (sumtemp + bytes[i]);

            i++;
        }
        if (isNot)
            sumtemp = (byte) ~sumtemp;
        return sumtemp;
    }

    public static byte getOrByte(byte b1, byte orByte) {
        byte temp = 0x00;
        temp = (byte) (b1 | orByte);
        return temp;
    }

    /**
     * 取字节的非
     *
     * @param bytea
     * @return
     */
    public static byte getByteFromByteNon(byte bytea) {
        return (byte) ~bytea;
    }

    public static byte[] getNonBytes(byte[] bytes) {
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) ~bytes[i];
        }
        return bytes;
    }

    // //////////////////////////////////////////////////////////////////////////////////////////////////////
    // 字节向字符的转向方法

    /**
     * 将指定byte数组以16进制的形式打印到控制台
     *
     * @param hint String
     * @param b    byte[]
     * @return void
     */
    public static void printHexString(String hint, byte[] b) {
        System.out.print(hint);
        for (int i = 0; i < b.length; i++) {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            System.out.print(hex.toUpperCase() + " ");
        }
        System.out.println("");
    }

    /**
     * 将16位的字节串，返回16位字符串
     *
     * @param b byte[] 字节串 例：0x0B;
     * @return String 返回 0x0B&0xFF 0x0B Integer.toHexString(0x0B&0xFF)
     * &与(两个相应位都为1 则为1，否为0) 若高位有零，得值为b,则高位补0为0B;
     */
    public static String Bytes2HexString(byte[] b) {
        String ret = "";
        for (int i = 0; i < b.length; i++) {

            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            ret += hex.toUpperCase();
        }
        return ret;
    }

    /**
     * 将16位的字节，返回16位字符串
     *
     * @param b byte[] 字节串 例：0x0B;
     * @return String 返回 0x0B&0xFF 0x0B Integer.toHexString(0x0B&0xFF)
     * &与(两个相应位都为1 则为1，否为0) 若高位有零，得值为b,则高位补0为0B;
     */
    public static String Bytes2HexString(byte b) {
        String ret = "";

        String hex = Integer.toHexString(b & 0xFF);
        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        ret += hex.toUpperCase();
        return ret;
    }

    // //////////////////////////////////////////////////////////////////////////////////////////////////////
    // 字符向字节转换方法

    /**
     * 将两个ASCII字符合成一个字节； 如："EF"--> 0xEF
     *
     * @param src0 byte 第一位向左移位4 例:2<<4 0x02 00000010=2 0x20 00100000=32
     * @param src1 byte 第二位按正常操作 例:0x0B 00001011
     * @return byte 返回两个ASCII字符的十六进制 例:0x20^0x0B的按位异或(两面相应位相同，则0，否则1) 0x2B
     * 00100000^00001011=00101011
     */
    public static byte uniteBytes(byte src0, byte src1) {
        byte _b0 = Byte.decode("0x" + new String(new byte[]{src0}))
                .byteValue();
        // byte _b0=src0;
        _b0 = (byte) (_b0 << 4);
        byte _b1 = Byte.decode("0x" + new String(new byte[]{src1}))
                .byteValue();
        // byte _b1=src1;
        byte ret = (byte) (_b0 ^ _b1);
        return ret;
    }

    /**
     * 将指定字符串src，以每两个字符分割转换为16进制形式 如："2B44EFD9" --> byte[]{0x2B, 0x44, 0xEF,
     * 0xD9}
     *
     * @param src String
     * @return byte[]
     */
    public static byte[] HexString2Bytes(String src) {
        byte[] ret = new byte[src.length() / 2];
        byte[] tmp = src.getBytes();
        for (int i = 0; i < src.length() / 2; i++) {
            ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
        }
        return ret;
    }

    /**
     * 根据二进制字节串，转换为字节 例:01101111 6F
     *
     * @param src    二进制字节
     * @param number 位数 8个倍数
     * @return 字节串
     */
    @SuppressWarnings("static-access")
    public static byte[] getBytesByStrbinary(String src, int number) {
        byte[] tmp = new byte[number / 8];
        for (int i = 0; i < tmp.length; i++) {
            String temp = src.copyValueOf(src.toCharArray(), i * 8, 8);
            tmp[i] = intTobyte(Integer.valueOf(temp, 2).intValue());
        }
        return tmp;
    }

    /**
     * 将二进制数据转换为十六进制数据
     *
     * @param binaryStr
     * @return
     */
    public static String binary2Hex(String binaryStr) {
        int ii = 0;
        int len = binaryStr.length();
        // 不够8bit左补0
        if (len % 8 != 0) {
            while (ii < 8 - len % 8) {
                binaryStr = "0" + binaryStr;
            }
        }

        byte[] tmp = new byte[binaryStr.length() / 8];
        for (int i = 0; i < tmp.length; i++) {
            String temp = binaryStr.copyValueOf(binaryStr.toCharArray(), i * 8, 8);
            tmp[i] = intTobyte(Integer.valueOf(temp, 2).intValue());
        }
        return Bytes2HexString(tmp);
    }


    /**
     * 字符串src 以"2B" 转换为 0x2B 若 "2Z" 则报错。
     *
     * @param src
     * @return
     */
    public static byte HexString2Byte(String src) {
        byte[] tmp = src.getBytes();
        return uniteBytes(tmp[0], tmp[1]);
        // return Byte.decode("0x" + src).byteValue();
    }

    /**
     * 判断字节串是否为字节串
     *
     * @param src
     * @return
     */
    public static boolean isBytesStr(String src) {
        try {
            byte[] ret = new byte[src.length() / 2];
            byte[] tmp = src.getBytes();
            for (int i = 0; i < src.length() / 2; i++) {
                ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
            }
            return true;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            return false;
        }

    }

    /**
     * 将十六进制转换为二进制 "1A" "00011010"
     *
     * @param src
     * @return
     */
    public static String HexString2String(String src) {
        if (null == src || "".equals(src))
            return "";
        int length = src.length();
        String number = "";
        for (int i = 0; i < length; i++) {
            String temp = src.substring(i, i + 1);
            byte tmp = HexString2Byte("0" + temp);
            int values = tmp;
            temp = Integer.toBinaryString(values);
            String lin = "";
            for (int j = 4; j > temp.length(); j--) {
                lin += "0";
            }
            temp = lin + temp;
            number += temp;
        }
        return number;
    }

    /**
     * 将一个数字转变为字节,只限写卡时使用
     *
     * @param number 需要处理的整数
     * @param size
     * @return 字节数
     */
    public static byte[] intToByteArray(int number, int size) {
        byte[] result = new byte[size];
        int s = 0;
        for (int i = 0; i < size; i++) {
            if (i == 0)
                result[i] = (byte) (number & 0xFF);
            else
                result[i] = (byte) (number >> s & 0xFF);
            s += 8;
        }
        return result;
    }

    /**
     * 将一个整数，用字节16进制数组表制
     *
     * @param number
     * @param max
     * @return
     */
    public static byte[] intToByteArray2(long number, int max) {
        byte[] result = new byte[max];
        for (int i = 0; i < max; i++) {
            if (i != max - 1)
                result[i] = (byte) (number >> ((max - 1) - i) * 8 & 0xFF);
            else
                result[i] = (byte) (number & 0xFF);
        }
        return result;
    }

    /**
     * 将一个整数，用十六进制数组表标
     *
     * @param values
     * @return
     */
    public static byte[] intToBytesByValues(int values) {
        char[] s = String.valueOf(values).toCharArray();
        byte[] result = new byte[s.length];
        if (values < 0)
            return result;
        for (int i = 0; i < s.length; i++) {
            int temp = Integer.valueOf(String.valueOf(s[i]));
            result[i] = (byte) temp;
        }
        return result;
    }

    /**
     * 将十进制字符，将转为十六进制
     *
     * @param Str
     * @return
     */
    public static String getHexStr(String Str) {
        int length = Str.length() / 2;
        int i = 0;
        String temp = "";
        while (i < length) {
            String s = Str.substring(i * 2, i * 2 + 2);
            temp += Bytes2HexString(intTobyte(Integer.valueOf(s)));
            i++;
        }
        return temp;
    }

    /**
     * 将数字转换为字节
     *
     * @param number
     * @return
     */
    public static byte intTobyte(int number) {
        return (byte) (number & 0xFF);
    }

    /**
     * 将字节数组转换为数字
     *
     * @param bytes
     * @return
     */
    public static int byteToInt(byte[] bytes) {
        int mask = 0xff;
        int temp = 0;
        int n = 0;
        for (int i = 0; i < bytes.length; i++) {
            n <<= 8;
            temp = bytes[i] & mask;
            n |= temp;
        }
        return n;
    }

    /**
     * 单个字节改换为数字
     *
     * @param tmp
     * @return
     */
    public static int byteToInt(byte tmp) {
        return tmp & 0xff;
    }

    /**
     * 将8位字节串异或，得到异或值
     *
     * @param b     需要处理的字节串 例： 0xA7^0x03^0x13=0xB7
     * @param isNOT 取非
     * @return 返回得到异或字节串 实际得到只是一个字节，为了处理方便用字节串
     */
    public static byte XOrBytes(byte[] b, boolean isNOT) {

        byte temp = 0x00;
        // 如果字节串长度大于是，则改变初始化temp的值。
        if (b.length > 1)
            temp = b[0];
            // 字节串为空时，直接返回
        else {
            if (true == isNOT)
                return (byte) ~temp;
            return temp;
        }
        int i = 1;
        // 字节串大于是时，才处理异或操作
        while (b.length > i) {
            // 执行异或
            temp = (byte) (temp ^ b[i]);
            i++;
        }

        if (true == isNOT)
            return (byte) ~temp;
        return temp;

    }

    /**
     * 将8位字节串异或，得到异或值
     *
     * @param a 需要处理的字节串
     * @param b 需要处理的字节串
     * @return 返回异或结果级
     */
    public static byte[] XOrBytes(byte[] a, byte[] b) {

        if (a.length != b.length)
            return null;
        byte[] relByte = new byte[a.length];
        for (int i = 0; i < a.length; i++) {
            relByte[i] = (byte) (a[i] ^ b[i]);
        }

        return relByte;

    }

    /**
     * 将两个字节串异或，获得异或字节串
     *
     * @param a      字节串
     * @param b      字节串
     * @param length 字节串大小
     * @return length 大小的字节串
     */
    public static byte[] XorBytes(byte[] a, byte[] b, int length) {
        byte[] temp = new byte[length];
        for (int i = 0; i < length; i++) {
            temp[i] = (byte) (a[i] ^ b[i]);
        }
        return temp;
    }

    /**
     * 按指定类型 16，10，8进制类型，得到十进制数
     *
     * @param number
     * @param type
     * @return 出现错误返回值为0
     */
    public static int byteBinary(String number, int type) {
        try {
            // 若为16进制数时，则直接按16进制转10进制运算
            if (number.indexOf('x') > 0) {
                // is hex number
                if (number.length() <= 2) { // exception for "0x"
                    return 0;
                }
                return Integer.parseInt(
                        number.substring(number.indexOf('x') + 1,
                                number.length()), 16);
            } else
                return Integer.valueOf(number, type).intValue();
        } catch (NumberFormatException e) {
            return 0;
        }
    }

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * 获得字节数组中有效数据位 例如：01020304000000 有校四位 000000为无校数据
     *
     * @param bytes
     * @return
     */
    public static int bytesNilNumber(byte[] bytes) {
        if (bytes == null || bytes.length == 0)
            return -1;
        int number = bytes.length;
        int Nilflag = 0;
        for (int i = bytes.length - 1; i >= 0; i--) {
            // 不为零时，则退出
            if (0 != bytes[i])
                break;
            Nilflag++;
        }
        return number - Nilflag;
    }

    /**
     * 字节流解码为正确的字符流
     *
     * @param bytes  字节流
     * @param number 字节流的有效位数
     * @return
     */
    public static String getStringGDKByBytes(byte[] bytes, int number) {
        ByteBuffer by = ByteBuffer.wrap(bytes, 0, number);
        Charset charset = Charset.forName("GBK");
        CharBuffer cb = charset.decode(by);
        return cb.toString();
    }

    /**
     * 字节流解码为正确的字符流
     *
     * @param strBytes 字节流的有效位数
     * @return
     */
    public static String getStringGDKByStrBytes(String strBytes) {
        byte[] bytes = byteUtils.HexString2Bytes(strBytes);
        ByteBuffer by = ByteBuffer.wrap(bytes, 0, bytes.length);
        Charset charset = Charset.forName("GBK");
        CharBuffer cb = charset.decode(by);
        return cb.toString();
    }

    /**
     * 将字节HEX时间转换为正常时间
     *
     * @param hexTime 需要转换的时间
     * @return
     */
    public static String HexTimeToDateTime(String hexTime) {
        if (hexTime == null || hexTime.length() != 12)
            return null;
        String DateTime = "";
        for (int i = 0; i < 6; i++) {

            String temp = String.valueOf(Integer.parseInt(hexTime.substring(i * 2, i * 2 + 2), 16));
            if (temp.length() == 1)
                temp = "0" + temp;

            if (i == 0)
                temp = "20" + temp;
            DateTime += temp;

        }
        return DateTime;
    }

    /**
     * 将字节HEX时间转换为正常时间
     *
     * @param DateTime 需要转换的时间
     * @return
     */
    public static String DateTimeToHexTime(String DateTime) {
        if (DateTime == null || DateTime.length() != 12)
            return null;
        String HexTime = "";
        for (int i = 0; i < 6; i++) {
            HexTime += byteUtils.Bytes2HexString(byteUtils.intTobyte(Integer.parseInt(DateTime.substring(i * 2, i * 2 + 2), 10)));
        }
        return HexTime;
    }

    // //////////////////////////////////////////////////////////////////////////////////////////////////////////

    public static void main(String[] args) {
        // 0126A172

        System.out.println(byteUtils.Bytes2HexString(byteUtils.XOrBytes(byteUtils.intToByteArray2(1616570160810L,6),false)));

        System.out.println(byteUtils.Bytes2HexString(byteUtils.getByteByBytesSum(byteUtils.intToByteArray2(1616570160810L,6),false)));
        System.out.println(byteUtils.getASCII("中"));
        String message = "A";
        System.out.println(byteUtils.Bytes2HexString(byteUtils
                .getBytesByGB2312String(message, message.length())));

        System.out.println(byteUtils.Bytes2HexString(byteUtils.XOrBytes(byteUtils.HexString2Bytes("2B44EFD9"), false)));

        System.out.println(byteUtils.Bytes2HexString(byteUtils.getByteByBytesSum(byteUtils.HexString2Bytes("202122232425262728292A2B2C2D2E"), false)));

        System.out.println(DateTimeToHexTime("181224010203"));

        System.out.println(byteUtils
                .Bytes2HexString(intToByteArray2(100, 4)));
        if (1 == 1)
            return;
        byte[] bytes = new byte[4];
        bytes[0] = (byte) ~0x01;
        bytes[1] = (byte) ~0x26;
        bytes[2] = (byte) ~0xA1;
        bytes[3] = (byte) ~0x72;
        System.out.println(byteUtils.Bytes2HexString(bytes));

        System.out
                .println(byteUtils.Bytes2HexString(byteUtils.XOrBytes(byteUtils
                                .HexString2Bytes("A3AE2379BC19F9CB81E3"),
                        true)));

        System.out.println("sum:" + byteUtils.Bytes2HexString(byteUtils
                .getByteByBytesSum(
                        byteUtils.HexString2Bytes("0174F11038B7576AAF08BAD9"),
                        true)));

        System.out
                .println("B2E2CAD4D1E92020D7DCB2BFC3C52020202000000320140225171754271000000000271001B9DCC0EDD4B163"
                        .length() / 2);


        System.out.println(byteUtils.Bytes2HexString(byteUtils
                .getBytesByGB2312String2(message, 3)));
        System.out
                .println(getStringGDKByStrBytes("3132BCB6D0C2C9FAC1D9CAB12020"));
        if (1 == 1)
            return;
        byte t = (byte) 0x41;

        System.out.println(byteUtils.Bytes2HexString((byte) ~t));
        System.out.println(byteUtils.Bytes2HexString("B".getBytes()));
        //byte[] bytes = new byte[1];
        bytes[0] = 0x42;
        System.out.println(getStringGDKByStrBytes("FF41"));
        System.out.println("b="
                + byteUtils.Bytes2HexString(byteUtils.getBytesByGB2312String(
                "EncryptPar", 4)));

        // A3 1E 12 FF FF FF FF FF FF 3C 0D BE 0B 00 00 00 00 00 FF 00 00 00 00
        // 00 00 00 FF 00 01

        // byte[] b = new byte[] { (byte) 0xA3, (byte) 0x1E, (byte) 0x12,(byte)
        // 0xFF,(byte) 0xFF,(byte) 0xFF,(byte) 0xFF,(byte) 0xFF,(byte)
        // 0xFF,(byte) 0x3C };
        // byte[] b = byteUtil.HexString2Bytes("A409101CE98EA303");
        // A7060001F4E068B4
        // System.out.println(byteUtil.Bytes2HexString(byteUtil.XOr(b)));
        // System.out.println(byteUtil
        // .Bytes2HexString(byteUtil.getInbyte(b, 0, 2)));

        // System.out.println(byteUtil
        // .Bytes2HexString(byteUtil.getReversalByte(b)));
        byte d = (byte) 0x00;

        byte f = (byte) (d * 4);
        System.out.println(byteUtils.Bytes2HexString(f));

        f = (byte) (d * 4 + 1);
        System.out.println(byteUtils.Bytes2HexString(f));

        /**
         * static String toBinaryString(int i) 以二进制（基数
         * 2）无符号整数形式返回一个整数参数的字符串表示形式。 static String toHexString(int i)
         * 以十六进制的无符号整数形式返回一个整数参数的字符串表示形式。 static String toOctalString(int i)
         * 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
         */

        System.out
                .println("EA="
                        + Integer.toBinaryString((byte) byteUtils
                        .HexString2Byte("11")));
        System.out.println(byteUtils.Bytes2HexString(byteUtils
                .HexString2Byte("11")));

        System.out.println("Byte=" + Integer.toBinaryString(0xF));
        System.out.println("Byte=" + Integer.toBinaryString((byte) 0x05));
        System.out.println(byteUtils.Bytes2HexString(byteUtils
                .getBytesByStrbinary("0110111101001011", 16)));
        System.out.println("A=" + byteUtils.HexString2String("A"));
        System.out.println(byteUtils.byteBinary("000011E", 2));
        System.out.println(byteUtils.byteBinary("0x4d8", 16));

    }

}
